#pragma once 
#include "match_queue.hpp"
#include "room_manager.hpp"
#include "session_manager.hpp"
#include "online_user_manager.hpp"
#include "user_table.hpp"
#include "util.hpp"
#include "websocketpp/server.hpp"
#include "websocketpp/config/asio_no_tls.hpp"
#include <string>

#define WWWROOT "./wwwroot/"
class gobang_server {
    public:
    //成员初始化,以及服务器回调函数的设置
    gobang_server(const std::string &host,
    const std::string &user, const std::string &password,
    const std::string &db_name, uint16_t port=3306,
    const std::string &wwwroot=WWWROOT)
    :_web_root(wwwroot)
    ,_tb_user(host,user,password,db_name,port)
    ,_room_manager(&_tb_user,&_online_user_manager)
    ,_match_queue_manager(&_room_manager,&_tb_user,&_online_user_manager)
    ,_session_manager(&_wssrv)
    {
        _wssrv.set_access_channels(websocketpp::log::alevel::none);
        _wssrv.init_asio();
        _wssrv.set_reuse_addr(true);
        _wssrv.set_http_handler(std::bind(&gobang_server::http_callback,
        this,std::placeholders::_1));
        _wssrv.set_open_handler(std::bind(&gobang_server::wsopen_callback,
        this,std::placeholders::_1));
        _wssrv.set_close_handler(std::bind(&gobang_server::wsclose_callback,
        this,std::placeholders::_1));
        _wssrv.set_message_handler(std::bind(&gobang_server::wsmsg_callback,
        this,std::placeholders::_1,std::placeholders::_2));
    }
    void start(uint16_t port)
    {
       _wssrv.listen(port);
       _wssrv.start_accept();
       _wssrv.run();
    }
    private:
        //静态资源访问的根目录 ./wwwroot/  /register.html -> ./wwwroot/register.html
        std::string _web_root; 
        wsserver_t _wssrv;
        user_table _tb_user; 
        online_user_manager _online_user_manager;
        room_manager _room_manager;
        match_queue_manager _match_queue_manager;
        session_manager _session_manager; 
    private:
    
    //静态资源请求的处理
    void file_handler(wsserver_t::connection_ptr &conn) {
            //静态资源请求的处理
            //1. 获取到请求uri-资源路径，了解客户端请求的页面文件名称
            websocketpp::http::parser::request req = conn->get_request();
            std::string uri = req.get_uri();
            //2. 组合出文件的实际路径   相对根目录 + uri
            std::string realpath = _web_root + uri;
            //3. 如果请求的是个目录，增加一个后缀  login.html,    /  ->  /login.html
            if (realpath.back() == '/') {
                realpath += "login.html";
            }
            //4. 读取文件内容
            Json::Value resp_json;
            std::string body;
            bool ret = file_util::read(realpath, body);
            //  1. 文件不存在，读取文件内容失败，返回404
            if (ret == false) {
                body += "<html>";
                body += "<head>";
                body += "<meta charset='UTF-8'/>";
                body += "</head>";
                body += "<body>";
                body += "<h1> Not Found </h1>";
                body += "</body>";
                conn->set_status(websocketpp::http::status_code::not_found);
                conn->set_body(body);
                return;
            }
            //5. 设置响应正文
            conn->set_body(body);
            conn->set_status(websocketpp::http::status_code::ok);
        }

    //响应处理
    void http_resp(wsserver_t::connection_ptr &conn,bool result,
    websocketpp::http::status_code::value code,
    const std::string &reason)
    {
        Json::Value resp_json;
        resp_json["result"]=result;
        resp_json["reason"]=reason;
        std::string resp_body;
        json_util::serialize(resp_json,resp_body);
        conn->set_status(code);
        conn->set_body(resp_body);
        conn->append_header("Content-Type","application/json");
        return ;
    }

    // 用户注册功能请求的处理
    void reg(wsserver_t::connection_ptr &conn)
    {
        websocketpp::http::parser::request req = conn->get_request();
        // 1.获取请求的body
        std::string req_body = conn->get_request_body();
        // 2.对正文中的json反序列化
        Json::Value login_info;
        bool ret = json_util::unserialize(req_body, login_info);
        if (!ret)
        {
            DBG_LOG("注册:json反序列化失败");
            return http_resp(conn, false,
            websocketpp::http::status_code::bad_request, "请求的正文格式错误");
        }
        // 3.进行数据库的用户新增操作---注册---向表中插入数据
        if (login_info["username"].isNull() ||
            login_info["password"].isNull())
        {
            // 用户和密码其中一个输入为空
            DBG_LOG("用户名或者密码不完整");
            return http_resp(conn, false,
            websocketpp::http::status_code::bad_request, "请输入用户名或者密码");
        }
        ret=_tb_user.insert(login_info);//插入用户信息---注册
        if(!ret)
        {
            //插入失败，说明用户名被占用
            DBG_LOG("向数据库插入数据失败，用户名被占用");
             return http_resp(conn, false,
            websocketpp::http::status_code::bad_request, "用户名已被占用");
        }
        //如果成功，返回200
        return http_resp(conn,true,websocketpp::http::status_code::ok,"注册用户成功");
    }

    //用户登录功能请求的处理
    void login(wsserver_t::connection_ptr &conn)
    {
        //1.获取请求正文，进行反序列化，得到用户名和密码
         DBG_LOG("开始处理登录请求");
        std::string req_body=conn->get_request_body();
          DBG_LOG("请求正文: %s", req_body.c_str());
        Json::Value login_info;
        bool ret=json_util::unserialize(req_body,login_info);
        if(!ret)
        {
            DBG_LOG("反序列化失败");
            return http_resp(conn, false,
            websocketpp::http::status_code::bad_request, "请求的正文格式错误");
        }
         DBG_LOG("反序列化成功");
          DBG_LOG("用户名: %s", login_info["username"].isString() ? login_info["username"].asCString() : "非字符串");
        DBG_LOG("密码: %s", login_info["password"].isString() ? login_info["password"].asCString() : "非字符串");
        //2.校验正文的完整性，进行用户数据的验证
        if(login_info["username"].isNull()||
        login_info["password"].isNull())
        {
            DBG_LOG("用户名或者密码不完整");
            return http_resp(conn, false,
            websocketpp::http::status_code::bad_request, "请输入用户名或者密码");
        }

        //3.用户数据完整，需要验证---登录
        DBG_LOG("开始数据库验证");
        ret=_tb_user.login(login_info);
        if(!ret){
            //验证失败，返回400
            DBG_LOG("用户名或者密码错误");
            return http_resp(conn, false,
            websocketpp::http::status_code::bad_request, "用户名或者密码错误");
        }
         DBG_LOG("数据库验证成功");
        //4.验证成功，给客户端创建session
        uint64_t uid=login_info["id"].asUInt64();
        session_ptr ssp=_session_manager.create_session(uid,LOGIN);
        if(ssp.get()==nullptr){
            DBG_LOG("创建session失败");
            return http_resp(conn, false,
            websocketpp::http::status_code::internal_server_error, "创建会话失败");   
        }
        //创建会话成功
        _session_manager.set_session_expire_time(ssp->get_ssid(),SESSION_TIMEOUT);
        //5.设置响应头部
        std::string cookie_ssid="SSID="+std::to_string(ssp->get_ssid());
        conn->append_header("Set-Cookie",cookie_ssid);
        return http_resp(conn,true,websocketpp::http::status_code::ok,"登录成功");
    }
    
    //  Cookie:SSID=xxx;path=/;
    bool get_cookie_val(const std::string &cookie_str,const std::string&key,
    std::string& val)
    {
        //1.以;为间隔，将字符串分隔，得到各个单个的cookie信息
        std::string sep=";";
        std::vector<std::string> cookie_arr;
        string_util::split(cookie_str,sep,cookie_arr);
        for(auto str:cookie_arr){
            //2.对单个cookie字符串进行分隔,以=为分隔符，分离key和value
            std::vector<std::string> tmp_arr;
            string_util::split(str,"=",tmp_arr);
            if(tmp_arr.size()!=2){
                continue;
            }
            if(tmp_arr[0]==key){
                val=tmp_arr[1];
                return true;
            }
        }
        return false;
    }

    //用户信息获取功能请求的资源
    void info(wsserver_t::connection_ptr &conn)
    {
        Json::Value err_resp;
        //1.获取请求信息中的cookie，从cookie中获取session id
        std::string cookie_str=conn->get_request_header("Cookie");
        DBG_LOG("Cookie字符串: %s", cookie_str.c_str());
        if(cookie_str.empty())
        {
            DBG_LOG("请求的cookie为空");
            return http_resp(conn, false,
            websocketpp::http::status_code::bad_request, "请求的cookie为空,请重新登录");
        }
        //表示从cookie中获取ssid成功
        std::string ssid_str;
        bool ret=get_cookie_val(cookie_str,"SSID",ssid_str);
        DBG_LOG("从Cookie中提取SSID结果: %s, SSID值: %s", ret ? "成功" : "失败", ssid_str.c_str());
        if(!ret)
        {
            DBG_LOG("从cookie中获取ssid失败");
            return http_resp(conn, false,
            websocketpp::http::status_code::bad_request, "请求的cookie格式错误");
        }
        //2.在session管理中查找对应的会话信息
        try{
            long ssid = std::stol(ssid_str);
            DBG_LOG("解析SSID: %ld", ssid);
        session_ptr ssp=_session_manager.get_session_by_ssid(ssid);
        if(ssp.get()==nullptr){
            DBG_LOG("session不存在");
            return http_resp(conn, false,
            websocketpp::http::status_code::bad_request, "登录过期，请重新登录");
        }
        //3.从数据库中取出用户信息，进行序列化发送给客户端
        uint64_t uid=ssp->get_uid();
        Json::Value user_info;
        ret=_tb_user.get_by_user_id(uid,user_info);
        if(!ret){
            DBG_LOG("用户信息不存在");
            return http_resp(conn, false,
            websocketpp::http::status_code::bad_request, "用户信息不存在,请重新登录");
        }
        std::string resp_body;
        json_util::serialize(user_info,resp_body);
        if(!ret)
        {
            DBG_LOG("序列化失败");
            return http_resp(conn, false,
            websocketpp::http::status_code::internal_server_error, "序列化失败");
        }
         DBG_LOG("响应内容: %s", resp_body.c_str());
        conn->set_body(resp_body);
        conn->append_header("Content-Type","application/json");
        conn->set_status(websocketpp::http::status_code::ok);
        
        //4.刷新session的过期时间
        _session_manager.set_session_expire_time(ssp->get_ssid(),SESSION_TIMEOUT);
        }
        catch (const std::exception& e) {
            DBG_LOG("处理过程中发生异常: %s", e.what());
            return http_resp(conn, false,
            websocketpp::http::status_code::internal_server_error, "服务器内部错误");
        }
    }

    void http_callback(websocketpp::connection_hdl hdl)
    {
        DBG_LOG("HTTP回调开始处理");
        wsserver_t::connection_ptr conn=_wssrv.get_con_from_hdl(hdl);
        websocketpp::http::parser::request req=conn->get_request();
        std::string req_method=req.get_method();
        std::string uri=req.get_uri();
         DBG_LOG("请求方法: %s, URI: %s", req_method.c_str(), uri.c_str());
        if(req_method=="POST"&&uri=="/reg"){
             DBG_LOG("处理注册请求");
            return reg(conn);
        }
        else if(req_method=="POST"&&uri=="/login"){
             DBG_LOG("处理登录请求");
            return login(conn);
        }
        else if(req_method=="GET"&&uri=="/info"){
              DBG_LOG("处理用户信息请求");
            return info(conn);
        }
        else{
              DBG_LOG("处理静态文件请求");
            return file_handler(conn);
        }
    }

    //把传入的响应序列化然后发送出去
    void ws_resp(wsserver_t::connection_ptr &conn,Json::Value&resp)
    {
        std::string body;
        json_util::serialize(resp,body);
        conn->send(body);
    }

    //从cookie中获取session
    session_ptr get_session_by_cookie(wsserver_t::connection_ptr &conn)
    {
        Json::Value err_resp;
        //1.获取请求信息
        std::string cookie_str = conn->get_request_header("Cookie");
        if(cookie_str.empty())
        {
            //如果没有cookie，返回错误
            err_resp["optype"] = "hall_ready";
            err_resp["reason"] = "没有找到cookie信息，需要重新登录";
            err_resp["result"]=false;
            ws_resp(conn,err_resp);
            return session_ptr();
        }
        //从cookie中获取ssid
        std::string ssid_str;
        bool ret=get_cookie_val(cookie_str,"SSID",ssid_str);
        if(!ret)
        {
           //cookie中没有ssid，返回错误
           err_resp["optype"]="hall_ready";
           err_resp["reason"] = "没有找到SSID信息，需要重新登录";
           err_resp["result"]=false;
           ws_resp(conn,err_resp);
           return session_ptr(); 
        }
        //2.在session管理中查找对应的会话信息
        session_ptr ssp=_session_manager.get_session_by_ssid(std::stol(ssid_str));
        if(ssp.get()==nullptr){
            err_resp["optype"]="hall_ready";
            err_resp["reason"] = "没有找到SSID信息，需要重新登录";
            err_resp["result"]=false;
            ws_resp(conn,err_resp);
            return session_ptr();
        }
        return ssp;
    }

    //游戏大厅长连接建立成功
    void wsopen_game_hall(wsserver_t::connection_ptr &conn)
    {
        Json::Value resp_json;
        //1.登录验证---判断当前客户端是否已经成功登录
        session_ptr ssp=get_session_by_cookie(conn);
        if(ssp.get()==nullptr)
        {
            return;
        }
        //2.判断当前客户端是否是重复登录
        if(_online_user_manager.in_hall(ssp->get_uid())||
        _online_user_manager.in_room(ssp->get_uid())){
            resp_json["optype"]="hall_ready";
            resp_json["reason"]="当前用户已经登录";
            resp_json["result"]=false;
            return ws_resp(conn,resp_json);
        }
        //3.成功登录并且没有重复登录，将当前客户端已经连接加入到游戏大厅
        _online_user_manager.enter_hall(ssp->get_uid(),conn);
        //4.将客户端响应游戏大厅连接建立成功
        resp_json["optype"]="hall_ready";
        resp_json["result"]=true;
        ws_resp(conn,resp_json);
        //5.刷新session的过期时间
        _session_manager.set_session_expire_time(ssp->get_ssid(),SESSION_TIMEOUT);
    }
    
    //游戏房间长连接建立成功
    void wsopen_game_room(wsserver_t::connection_ptr &conn)
    {
       Json::Value resp_json;
        //1.登录验证---判断当前客户端是否已经成功登录
        session_ptr ssp=get_session_by_cookie(conn);
        if(ssp.get()==nullptr)
        {
            return;
        }
         DBG_LOG("用户 %lu 尝试建立房间连接", ssp->get_uid());
         
          
        //2.判断当前客户端是否已经在房间中
        if(_online_user_manager.in_room(ssp->get_uid())){
            DBG_LOG("用户 %lu 已在房间中，允许重新连接", ssp->get_uid());
            // 用户已经在房间中，直接获取房间信息
            room_ptr rp=_room_manager.get_room_by_uid(ssp->get_uid());
            if(rp.get()==nullptr){
                resp_json["optype"]="room_ready";
                resp_json["reason"]="没有找到玩家的房间信息";
                resp_json["result"]=false;
                return ws_resp(conn,resp_json); 
            }
            // 将当前用户添加到在线用户管理的游戏房间中（更新连接）
            _online_user_manager.enter_room(ssp->get_uid(),conn);
            DBG_LOG("用户 %lu 重新连接到房间", ssp->get_uid());
            // 将session重新设置为永久存储
            _session_manager.set_session_expire_time(ssp->get_ssid(),SESSION_FOREVER);
            // 回复房间准备完毕，包含正确的房间信息
            resp_json["optype"]="room_ready";
            resp_json["result"]=true;
            resp_json["room_id"]=(Json::UInt64)rp->room_id();
            resp_json["uid"]=(Json::UInt64)ssp->get_uid();
            resp_json["white_id"]=(Json::UInt64)rp->get_white_id();
            resp_json["black_id"]=(Json::UInt64)rp->get_black_id();

            DBG_LOG("发送房间准备消息: %s", resp_json.toStyledString().c_str());
            
            return ws_resp(conn,resp_json);
        }
        
        //3.判断当前用户是否已经建立好了房间
        room_ptr rp=_room_manager.get_room_by_uid(ssp->get_uid());
        if(rp.get()==nullptr){
            resp_json["optype"]="room_ready";
            resp_json["reason"]="没有找到玩家的房间信息";
            resp_json["result"]=false;
            return ws_resp(conn,resp_json); 
        }
        //4.将当前用户添加到在线用户管理的游戏房间中
        _online_user_manager.enter_room(ssp->get_uid(),conn);
         DBG_LOG("用户 %lu 成功进入房间", ssp->get_uid());
        //5.将session重新设置为永久存储
        _session_manager.set_session_expire_time(ssp->get_ssid(),SESSION_FOREVER);
        //6.回复房间准备完毕
        resp_json["optype"]="room_ready";
        resp_json["result"]=true;
        resp_json["room_id"]=(Json::UInt64)rp->room_id();
        resp_json["uid"]=(Json::UInt64)ssp->get_uid();
        resp_json["white_id"]=(Json::UInt64)rp->get_white_id();
        resp_json["black_id"]=(Json::UInt64)rp->get_black_id();

         DBG_LOG("发送房间准备消息: %s", resp_json.toStyledString().c_str());
        
        return ws_resp(conn,resp_json);
        }
    //websocket长连接建立成功之后的处理函数
    void wsopen_callback(websocketpp::connection_hdl hdl)
    {
        wsserver_t::connection_ptr conn=_wssrv.get_con_from_hdl(hdl);
    websocketpp::http::parser::request req=conn->get_request();
    std::string uri=req.get_uri();
    
    DBG_LOG("WebSocket连接建立: URI=%s", uri.c_str());
    
    if(uri=="/hall"){
        return wsopen_game_hall(conn);
    }
    else if(uri=="/room"){
        return wsopen_game_room(conn);
    }
    else{
        DBG_LOG("未知的WebSocket连接URI: %s", uri.c_str());
    }
    }

    //游戏大厅长连接断开处理
    void wsclose_game_hall(wsserver_t::connection_ptr conn)
    {
        //1.登录验证--判断当前客户端是否已经成功登录
        session_ptr ssp = get_session_by_cookie(conn);
        if(ssp.get()==nullptr)
        {
            return;
        }
        //1.将玩家从游戏大厅中移除
        _online_user_manager.exit_hall(ssp->get_uid());
        //2.将session恢复生命周期的管理，设置定时销毁
        _session_manager.set_session_expire_time(ssp->get_ssid(),SESSION_TIMEOUT);
    }

    //游戏房间长连接断开处理
    void wsclose_game_room(wsserver_t::connection_ptr conn)
    {
        //1.登录验证--判断当前客户端是否已经成功登录
        session_ptr ssp = get_session_by_cookie(conn);
        if(ssp.get()==nullptr)
        {
            return;
        }
        //1.将玩家从游戏房间中移除
        _online_user_manager.exit_room(ssp->get_uid());
         DBG_LOG("用户 %lu 退出房间", ssp->get_uid());
        //2.将session恢复生命周期的管理，设置定时销毁
        _session_manager.set_session_expire_time(ssp->get_ssid(),SESSION_TIMEOUT);
        //3.将玩家从游戏房间中移除，房间中所有用户退出就会销毁房间
        _room_manager.destroy_room_user(ssp->get_uid());
    }
    
    //websocket长连接断开之后的处理函数
    void wsclose_callback(websocketpp::connection_hdl hdl)
    {
        wsserver_t::connection_ptr conn=_wssrv.get_con_from_hdl(hdl);
        websocketpp::http::parser::request req=conn->get_request();
        std::string uri=req.get_uri();
        if(uri=="/hall"){
            //客户端为了关闭游戏大厅长连接
            return wsclose_game_hall(conn);
        }
        else if(uri=="/room"){
            //客户端为了关闭游戏房间长连接
            return wsclose_game_room(conn);
        }
    }

    void wsmsg_game_hall(wsserver_t::connection_ptr conn,
    wsserver_t::message_ptr msg)
    {
        Json::Value resp_json;
        std::string resp_body;
        //1.身份验证，当前客户端到底是哪个玩家
        session_ptr ssp=get_session_by_cookie(conn);
        if(ssp.get()==nullptr)
        {
            return;
        }
        //2.获取请求信息
        std::string req_body=msg->get_payload();
        Json::Value req_json;
        bool ret=json_util::unserialize(req_body,req_json);
        if(!ret)
        {
            resp_json["result"]=false;
            resp_json["reason"]="请求数据格式错误";
            return ws_resp(conn,resp_json);
        }
        //3.对于请求进行处理
        if(!req_json["optype"].isNull()&&req_json["optype"].asString()=="match_start")
        { 
            _match_queue_manager.add(ssp->get_uid());
            resp_json["optype"]="match_start";
            resp_json["result"]=true;
            return ws_resp(conn,resp_json);
        }
        else if(!req_json["optype"].isNull()&&req_json["optype"].asString()=="match_stop"){
            //停止对战匹配
            _match_queue_manager.del(ssp->get_uid());
            resp_json["optype"]="match_stop";
            resp_json["result"]=true;
            return ws_resp(conn,resp_json);
        }
        resp_json["optype"]="unknown";
        resp_json["reason"]="请求类型未知";
        resp_json["result"]=false;
        return ws_resp(conn,resp_json);
    }

    void wsmasg_game_room(wsserver_t::connection_ptr conn,
    wsserver_t::message_ptr msg)
    {
        Json::Value resp_json;
            //1. 获取客户端session，识别客户端身份
            session_ptr ssp = get_session_by_cookie(conn);
            if (ssp.get() == nullptr) {
                DBG_LOG("房间-没有找到会话信息");
                return;
            }
            //2. 获取客户端房间信息
            room_ptr rp = _room_manager.get_room_by_uid(ssp->get_uid());
            if (rp.get() == nullptr) {
                resp_json["optype"] = "unknow";
                resp_json["reason"] = "没有找到玩家的房间信息";
                resp_json["result"] = false;
                DBG_LOG("房间-没有找到玩家房间信息");
                return ws_resp(conn, resp_json);
            }
            //3. 对消息进行反序列化
            Json::Value req_json;
            std::string req_body = msg->get_payload();
            bool ret = json_util::unserialize(req_body, req_json);
            if (ret == false) {
                resp_json["optype"] = "unknow";
                resp_json["reason"] = "请求解析失败";
                resp_json["result"] = false;
                DBG_LOG("房间-反序列化请求失败");
                return ws_resp(conn, resp_json);
            }
            DBG_LOG("房间：收到请求：%s", req_body.c_str());
            //4. 通过房间模块进行消息请求的处理
            return rp->handle_request(req_json);
            DBG_LOG("房间：处理完成");
    }
    
    //websocket长连接收到消息之后的处理函数
    void wsmsg_callback(websocketpp::connection_hdl hdl,
    wsserver_t::message_ptr msg)    
   {
       wsserver_t::connection_ptr conn=_wssrv.get_con_from_hdl(hdl);
       websocketpp::http::parser::request req=conn->get_request();
       std::string uri=req.get_uri();
       if(uri=="/hall"){
           //处理游戏大厅长连接的消息
           return wsmsg_game_hall(conn,msg);
       }
       else if(uri=="/room"){
           //处理游戏房间长连接的消息
           return wsmasg_game_room(conn,msg);
       }
   }

};